	/* 
 * File:   main.c
 * Author: blastin
 *
 * Created on 22 de Junho de 2011, 01:57
 */
/*Devido o uso da blibioteca math.h
 * É necessário o uso de "-lm" na compilação dos objetos */

#include <stdio.h>
#include <math.h>

#include <stdlib.h>

#ifdef WIN32
        #include <conio.h>
#endif

#include "sys_index.h"

#define VERSAO "REVISAO [9] - Trunk"
#define AUTOR  "Blastin - KNiN PROJECT"


#define PI_RAD                      180
#define ANGULO(value_graus,att)     att( (value_graus* M_PI) /PI_RAD) /*att : no caso a notaçao cos ou sin ou tan*/
#define BASE(velocidade,angulo)     (velocidade     * ANGULO(angulo,cos))
#define ALTURA(velocidade,angulo)   (velocidade     * ANGULO(angulo,sin))
#define QUEDA(velocidade,angulo)    (2*velocidade) *  ANGULO(angulo,cos)

extern map_info index_map;

/*
 * 
 */


void gprintf(map_info *,object_corpo *);
int vetor_moviment(char ,map_info * ,object_corpo *);
void moviment_automatic(object_corpo *,map_info * );


unsigned _saida = 0;
unsigned char _po;

int main(int argc, char** argv) {char posicao;object_corpo  corpo_coordenadas = search_corpo();
struct map_information * aaa = &index_map;
    gprintf(&index_map,&corpo_coordenadas);
    corpo_coordenadas.object.angulo         = 10;
    corpo_coordenadas.object.velocidade     = 30;
    corpo_coordenadas.object.local_queda_y  = 0;
    corpo_coordenadas.object.local_queda_x  = QUEDA(corpo_coordenadas.object.velocidade,PI_RAD/corpo_coordenadas.object.angulo);
    while(1){
#ifdef WIN32
      _po =   posicao = getch();
#else
        system("stty echo raw"); /*buffer ser inserção do enter : )*/
        _po = posicao = getchar(); /* pega a posição do usuario :*/
            /*
            D ou d : direção oeste ->>>>
            A ou a : direção leste <<<<-
            */
        system("stty echo -raw");
#endif
        _saida++;
        
        if (posicao == 'e' || posicao == 'E') break;
        else if(posicao == '8') (corpo_coordenadas.object.velocidade< MAX_VEL)? corpo_coordenadas.object.velocidade++ : NULL ;
        else if(posicao == '5') (corpo_coordenadas.object.velocidade> NULL)   ? corpo_coordenadas.object.velocidade-- : NULL ;
        else if(posicao == '9') (corpo_coordenadas.object.angulo    < MAX_ANG)? corpo_coordenadas.object.angulo++     : NULL;
        else if(posicao == '6') (corpo_coordenadas.object.angulo    > NULL+1) ? corpo_coordenadas.object.angulo--     : NULL;
        else if (posicao == 'u' || posicao == 'U') moviment_automatic(&corpo_coordenadas,&index_map);
        if ( ! vetor_moviment(posicao,&index_map,&corpo_coordenadas)) printf("\na\n");
        gprintf(&index_map,&corpo_coordenadas);
    }
    printf("termino ... knin \n");
    
    return -1;
}
void gprintf(map_info * object_map,object_corpo * corpo_info){ register int printf_linha,printf_coluna;
#ifdef WIN32
        system("cls");
#else
        system("clear");
#endif
printf("\t\t\t\t%s - %s\n",VERSAO,AUTOR);
for(printf_linha = 0;printf_linha < object_map->coordenadas_line;printf_linha++){
    for(printf_coluna = 0;printf_coluna < object_map->coordenadas_colun;printf_coluna++){
    printf("%c",object_map->index[printf_linha][printf_coluna] == MAP_LIMITE ? '\'' : \
    object_map->index[printf_linha][printf_coluna] == CORPO_CARACTERE ? '\"' : ' ');
        
        } 
    switch(printf_linha){
        case  0:  printf("\t\t\bInfomações do mapa : %s :: stdin(%c) : stdout(%d)",object_map->nome,_po,_saida);break;
        case  1:  printf("\t\tEixo y : %d\tEixo x: %d",object_map->coordenadas_line,object_map->coordenadas_colun);break;
        case  3:  printf("\t\t\bInformações sobre o corpo");break;
        case  4:  printf("Área : %d\tBase: %d\tAltura : %d",corpo_info->object.segmento_x  * corpo_info->object.segmento_y,\
                corpo_info->object.segmento_x,corpo_info->object.segmento_y);break;
        case  5:  printf("\tA{%.2d,%d}\tB{%.2d,%d}\tC{%.2d,%d}",corpo_info->a_x,\
                corpo_info->a_y,corpo_info->b_x,corpo_info->b_y,corpo_info->c_x,corpo_info->c_y);break;
        case  6:  printf("\tD{%.2d,%d}\tE{%.2d,%d}\tF{%.2d,%d}",corpo_info->d_x,\
                corpo_info->d_y,corpo_info->e_x,corpo_info->e_y,corpo_info->f_x,corpo_info->f_y);break;
        case  7:  printf("\tG{%.2d,%d}\tH{%.2d,%d}\tI{%.2d,%d}",corpo_info->g_x,\
                corpo_info->g_y,corpo_info->h_x,corpo_info->h_y,corpo_info->i_x,corpo_info->i_y);break;
        case  8:  printf("\tJ{%.2d,%d}\tK{%.2d,%d}\tL{%.2d,%d}",corpo_info->j_x,\
                corpo_info->j_y,corpo_info->k_x,corpo_info->k_y,corpo_info->l_x,corpo_info->l_y);break;
        case  9:  printf("\tM{%.2d,%d}\tN{%.2d,%d}\tO{%.2d,%d}",corpo_info->m_x,\
                corpo_info->m_y,corpo_info->n_x,corpo_info->n_y,corpo_info->o_x,corpo_info->o_y);break;
        case  10: printf("\tP{%.2d,%d}\tQ{%.2d,%d}\tR{%.2d,%d}",corpo_info->p_x,\
                corpo_info->p_y,corpo_info->q_x,corpo_info->q_y,corpo_info->r_x,corpo_info->r_y);break;
        case  11: printf("\tA  B  C  D  E  F  G");break;
        case  12: printf("\tH                 I");break;
        case  13: printf("\tJ                 K");break;
        case  14: printf("\tL  M  N  O  P  Q  R");break;
        case  17: printf("\t\tProtótipo de queda");break;
        case  18: printf("\t\bPower       : %d PColun\t\t Angulo  : %d Graus",corpo_info->object.velocidade,corpo_info->object.angulo);break;
        /*PC : power por coluna*/
        case  19: printf("\t\bBase        : %d m \t\t Altura  : %d m",\
        abs(BASE(corpo_info->object.velocidade,corpo_info->object.angulo)),\
        abs(ALTURA(corpo_info->object.velocidade,corpo_info->object.angulo)));
        break;
        
        case  20: printf("\t\bLocal Object: {%d,0}",\
        abs(QUEDA(corpo_info->object.velocidade,corpo_info->object.angulo)+corpo_info->l_x));
        break;
        
        }
    putchar('\n');
    }
    printf("Informações : \nKEY 9 : Aumenta angulação\t | KEY 6 : Diminui angulação\n- - - -\nKEY 8: Aumenta velocidade \
\t | KEY 5: Diminui velocidade\n");

}void moviment_automatic(object_corpo * corpo,map_info * mapa){int tempo,posicao_check = 1;
    printf("\n\n\nInsira o tempo de movimentação :\n");
    scanf("%d",&tempo);
    do{
        if(posicao_check && mapa->index[corpo->ponto_extremo_leste_y][corpo->ponto_extremo_leste_x+1] == MAP_LIVRE ){
            vetor_moviment('D',mapa,corpo);system("sleep 0.1");gprintf(mapa,corpo);
        }else posicao_check = 0;
        if(! (posicao_check) && mapa->index[corpo->ponto_extremo_oeste_y][corpo->ponto_extremo_oeste_x-1] == MAP_LIVRE){
            vetor_moviment('A',mapa,corpo);system("sleep 0.1");gprintf(mapa,corpo);
        }else posicao_check = 1;
    }while(--tempo);    
}int vetor_moviment(char player_moviment,map_info * mapa,object_corpo * m_c){
   /*
        player_moviment =  movimento que o player escolheu
        mapa            =  mapa do jogo
        m_c             =  coordenadas do corpo
    
 
                                1 1 1
                                5 3 1 9 7 5
  a = ponto_extremo_oeste       A,B,C,D,E,F,G ->1         g = ponto_extremo_leste
                                4,4,4,4,4,4,4
<<<<<<<<<<<<<===========    16H 4,0,0,0,0,0,4 I ->2       ===========>>>>>>>>>>>>>
                            17J 4,0,0,0,0,0,4 K ->3       
                                4,4,4,4,4,4,4
                                L,M,N,O,P,Q,R -> 4
                               18 1 1 1 8 6
                                  4 2 0
    *   #define MAP_LIVRE 0
        #define MAP_LIMITE 1
        #define CORPO_CARACTERE 4
  */

    switch(player_moviment){
        case 'd' : case 'D' : /* movimento - >>>>*/
            if (mapa->index[m_c->ponto_extremo_leste_y][m_c->ponto_extremo_leste_x+1] == MAP_LIVRE){
               
                 
                                      /*MOVIMENTO DA COORDENADA G ponto_extremo_leste*/
                mapa->index[m_c->g_y][m_c->g_x] = MAP_LIVRE;
                mapa->index[m_c->g_y][++(m_c->g_x)] = CORPO_CARACTERE;
                m_c->ponto_extremo_leste_x = m_c->g_x;
                 
                                      /*MOVIMENTO  DA COORDENADA I*/
                mapa->index[m_c->i_y][m_c->i_x] = MAP_LIVRE;
                mapa->index[m_c->i_y][++(m_c->i_x)] = CORPO_CARACTERE;
                 
                                    /*MOVIMENTO  DA COORDENADA K*/
                mapa->index[m_c->k_y][m_c->k_x] = MAP_LIVRE;
                mapa->index[m_c->k_y][++(m_c->k_x)] = CORPO_CARACTERE;
                 
                                    /*MOVIMENTO  DA COORDENADA R*/
                mapa->index[m_c->r_y][m_c->r_x] = MAP_LIVRE;
                mapa->index[m_c->r_y][++(m_c->r_x)] = CORPO_CARACTERE;
                 
                                    /*MOVIMENTO  DA COORDENADA F*/
                mapa->index[m_c->f_y][m_c->f_x] = MAP_LIVRE;
                mapa->index[m_c->f_y][++(m_c->f_x)] = CORPO_CARACTERE;
                 
                                    /*MOVIMENTO  DA COORDENADA Q*/
                mapa->index[m_c->q_y][m_c->q_x] = MAP_LIVRE;
                mapa->index[m_c->q_y][++(m_c->q_x)] = CORPO_CARACTERE;
                 
                                    /*MOVIMENTO  DA COORDENADA E*/
                mapa->index[m_c->e_y][m_c->e_x] = MAP_LIVRE;
                mapa->index[m_c->e_y][++(m_c->e_x)] = CORPO_CARACTERE;
                 
                                    /*MOVIMENTO  DA COORDENADA P*/
                mapa->index[m_c->p_y][m_c->p_x] = MAP_LIVRE;
                mapa->index[m_c->p_y][++(m_c->p_x)] = CORPO_CARACTERE;
                 
                                    /*MOVIMENTO  DA COORDENADA D*/
                mapa->index[m_c->d_y][m_c->d_x] = MAP_LIVRE;
                mapa->index[m_c->d_y][++(m_c->d_x)] = CORPO_CARACTERE;
                 
                                    /*MOVIMENTO  DA COORDENADA O*/
                mapa->index[m_c->o_y][m_c->o_x] = MAP_LIVRE;
                mapa->index[m_c->o_y][++(m_c->o_x)] = CORPO_CARACTERE;
                 
                                    /*MOVIMENTO  DA COORDENADA C*/
                mapa->index[m_c->c_y][m_c->c_x] = MAP_LIVRE;
                mapa->index[m_c->c_y][++(m_c->c_x)] = CORPO_CARACTERE;
                 
                                    /*MOVIMENTO  DA COORDENADA N*/
                mapa->index[m_c->n_y][m_c->n_x] = MAP_LIVRE;
                mapa->index[m_c->n_y][++(m_c->n_x)] = CORPO_CARACTERE;
                 
                                    /*MOVIMENTO  DA COORDENADA B*/
                mapa->index[m_c->b_y][m_c->b_x] = MAP_LIVRE;
                mapa->index[m_c->b_y][++(m_c->b_x)] = CORPO_CARACTERE;
                 
                                    /*MOVIMENTO  DA COORDENADA M*/
                mapa->index[m_c->m_y][m_c->m_x] = MAP_LIVRE;
                mapa->index[m_c->m_y][++(m_c->m_x)] = CORPO_CARACTERE;
                 
                                    /*MOVIMENTO  DA COORDENADA A*/
                mapa->index[m_c->a_y][m_c->a_x] = MAP_LIVRE;
                mapa->index[m_c->a_y][++(m_c->a_x)] = CORPO_CARACTERE;
                m_c->ponto_extremo_oeste_x = m_c->a_x;
                 
                                    /*MOVIMENTO  DA COORDENADA H*/
                mapa->index[m_c->h_y][m_c->h_x] = MAP_LIVRE;
                mapa->index[m_c->h_y][++(m_c->h_x)] = CORPO_CARACTERE;
                 
                                    /*MOVIMENTO  DA COORDENADA J*/
                mapa->index[m_c->j_y][m_c->j_x] = MAP_LIVRE;
                mapa->index[m_c->j_y][++(m_c->j_x)] = CORPO_CARACTERE;
                 
                                    /*MOVIMENTO  DA COORDENADA L*/
                mapa->index[m_c->l_y][m_c->l_x] = MAP_LIVRE;
                mapa->index[m_c->l_y][++(m_c->l_x)] = CORPO_CARACTERE;
                 
            }
            break;
        case 'a' : case 'A' : /* - <<< movimento*/

            if (mapa->index[m_c->ponto_extremo_oeste_y][m_c->ponto_extremo_oeste_x-1] == MAP_LIVRE){
                
                                    /*MOVIMENTO  DA COORDENADA A*/
                mapa->index[m_c->a_y][m_c->a_x] = MAP_LIVRE;
                mapa->index[m_c->a_y][--(m_c->a_x)] = CORPO_CARACTERE;
                m_c->ponto_extremo_oeste_x = m_c->a_x;
                 
                                    /*MOVIMENTO  DA COORDENADA H*/
                mapa->index[m_c->h_y][m_c->h_x] = MAP_LIVRE;
                mapa->index[m_c->h_y][--(m_c->h_x)] = CORPO_CARACTERE;
                
                                    /*MOVIMENTO  DA COORDENADA J*/
                mapa->index[m_c->j_y][m_c->j_x] = MAP_LIVRE;
                mapa->index[m_c->j_y][--(m_c->j_x)] = CORPO_CARACTERE;
                 
                                    /*MOVIMENTO  DA COORDENADA L*/
                mapa->index[m_c->l_y][m_c->l_x] = MAP_LIVRE;
                mapa->index[m_c->l_y][--(m_c->l_x)] = CORPO_CARACTERE;
                
                                    /*MOVIMENTO  DA COORDENADA B*/
                mapa->index[m_c->b_y][m_c->b_x] = MAP_LIVRE;
                mapa->index[m_c->b_y][--(m_c->b_x)] = CORPO_CARACTERE;
                
                                    /*MOVIMENTO  DA COORDENADA M*/
                mapa->index[m_c->m_y][m_c->m_x] = MAP_LIVRE;
                mapa->index[m_c->m_y][--(m_c->m_x)] = CORPO_CARACTERE;
                 
                                    /*MOVIMENTO  DA COORDENADA C*/
                mapa->index[m_c->c_y][m_c->c_x] = MAP_LIVRE;
                mapa->index[m_c->c_y][--(m_c->c_x)] = CORPO_CARACTERE;
                 
                                    /*MOVIMENTO  DA COORDENADA N*/
                mapa->index[m_c->n_y][m_c->n_x] = MAP_LIVRE;
                mapa->index[m_c->n_y][--(m_c->n_x)] = CORPO_CARACTERE;
                 
                                    /*MOVIMENTO  DA COORDENADA D*/
                mapa->index[m_c->d_y][m_c->d_x] = MAP_LIVRE;
                mapa->index[m_c->d_y][--(m_c->d_x)] = CORPO_CARACTERE;
                 
                                    /*MOVIMENTO  DA COORDENADA O*/
                mapa->index[m_c->o_y][m_c->o_x] = MAP_LIVRE;
                mapa->index[m_c->o_y][--(m_c->o_x)] = CORPO_CARACTERE;
                 
                                    /*MOVIMENTO  DA COORDENADA E*/
                mapa->index[m_c->e_y][m_c->e_x] = MAP_LIVRE;
                mapa->index[m_c->e_y][--(m_c->e_x)] = CORPO_CARACTERE;
                 
                                    /*MOVIMENTO  DA COORDENADA P*/
                mapa->index[m_c->p_y][m_c->p_x] = MAP_LIVRE;
                mapa->index[m_c->p_y][--(m_c->p_x)] = CORPO_CARACTERE;
               
                                    /*MOVIMENTO  DA COORDENADA F*/
                mapa->index[m_c->f_y][m_c->f_x] = MAP_LIVRE;
                mapa->index[m_c->f_y][--(m_c->f_x)] = CORPO_CARACTERE;
                
                                    /*MOVIMENTO  DA COORDENADA Q*/
                mapa->index[m_c->q_y][m_c->q_x] = MAP_LIVRE;
                mapa->index[m_c->q_y][--(m_c->q_x)] = CORPO_CARACTERE;
                
                                    /*MOVIMENTO DA COORDENADA G*  ponto_extremo_leste*/
                mapa->index[m_c->g_y][m_c->g_x] = MAP_LIVRE;
                mapa->index[m_c->g_y][--(m_c->g_x)] = CORPO_CARACTERE;
                m_c->ponto_extremo_leste_x = m_c->g_x;
                 
                                   /*MOVIMENTO  DA COORDENADA I*/
                mapa->index[m_c->i_y][m_c->i_x] = MAP_LIVRE;
                mapa->index[m_c->i_y][--(m_c->i_x)] = CORPO_CARACTERE;
               
                                    /*MOVIMENTO  DA COORDENADA K*/
                mapa->index[m_c->k_y][m_c->k_x] = MAP_LIVRE;
                mapa->index[m_c->k_y][--(m_c->k_x)] = CORPO_CARACTERE;
                
                                    /*MOVIMENTO  DA COORDENADA R*/
                mapa->index[m_c->r_y][m_c->r_x] = MAP_LIVRE;
                mapa->index[m_c->r_y][--(m_c->r_x)] = CORPO_CARACTERE;
                 
            }

       
            break;
    }
    return 1;
}
